home *** CD-ROM | disk | FTP | other *** search
/ Magnum One / Magnum One (Mid-American Digital) (Disc Manufacturing).iso / d12 / uasmls.arc / UASM.DOC < prev    next >
Text File  |  1986-08-12  |  26KB  |  759 lines

  1.                                                                           1
  2.  
  3.                                 UASM.DOC
  4.  
  5.           UASM  (for  Unassembler)  consists  of  five  files at this
  6.      time:  UASM.DOC, UASM-JMP.BAS,  UASM-INT.BAS,  UASM-STR.BAS  and
  7.      UASM-DOS.MAC,  with  the  purpose  of converting the unassembled
  8.      listing of a .COM file from DEBUG into a  .ASM  file  which  can
  9.      be modified and re-assembled with the Macro assembler.  
  10.  
  11.      **************************** NOTICE ****************************
  12.  
  13.         USER  SUPPORTED  SOFTWARE  (With  thanks to Andrew Flugelman)
  14.       
  15.      A limited license is granted to all  users  of  these  programs,
  16.      to  make  and  distribute  copies for other users subject to the
  17.      following conditions:                                 
  18.  
  19.           1.   None of the notices or credits  are  to  be  bypassed,
  20.                altered, or removed.
  21.           2.   The  programs  are  not  to be distributed in modified
  22.                form.  (Users  are  encouraged  to  distribute   MERGE
  23.                files.)
  24.           3.   No  fee  is  to be charged (or any other consideration
  25.                received) for copying  or  distributing  the  programs
  26.                without  an express written agreement with White Crane
  27.                Systems.                                 
  28.      ***************************************************************
  29.  
  30.                UASM - The White Crane Systems Unassembler 
  31.  
  32.           If you are using these program and finding  them  of  value
  33.      please  send  a  cash  contribution  to support their upkeep and
  34.      distribution.  Use the UASM system  of  programs  to  unassemble
  35.      one  average  length .COM file, look over the results and calcu-
  36.      late how many hours  this  would  have  taken  you  to  produce.
  37.      Multiply  this  by  the  minimum  wage,  contribute that amount,
  38.      and use the program free thereafter. If  that's  too  much  just
  39.      send  $20.   Supporters will receive free notice of enhancements
  40.      and updates. 
  41.           In any case you  are  encouraged  to  copy  and  distribute
  42.      UASM  to  your  friends  provided  you  do so free of charge and
  43.      in unmodified form. 
  44.       
  45.                              Guy C. Gordon 
  46.                           White Crane Systems 
  47.                           3194 Friar Tuck Way 
  48.                           Doraville, GA 30340 
  49.  
  50.  
  51.  
  52.  
  53.  
  54.  
  55.  
  56.  
  57.  
  58.  
  59.  
  60.  
  61.  
  62.  
  63.  
  64.  
  65.  
  66.  
  67.                                                                           2
  68.  
  69.                               INTRODUCTION
  70.  
  71.           The strategy used in this system is to capture  the  output
  72.      of  DEBUG  and  run  it through a series of BASIC programs, each
  73.      of which modifies one type of statement in the  listing,  making
  74.      it  more  like  an  .ASM  source  file.  This keeps each program
  75.      short and fast, and allows you to look over the output  at  each
  76.      step  to make sure no mistakes have been entered.  It also makes
  77.      the programs easy to understand and improve, as  new  steps  can
  78.      be  added  without  interfering  with  the first steps. Later in
  79.      its development UAand improve, as  new  steps  can
  80.      be  added  without  interfering  with  the first steps. Later in
  81.      its development UASM will combine  these  steps.   I  hope  that
  82.      users  of  these  programs  will  send  me their improvements so
  83.      that I may add them to future releases.  
  84.  
  85.           UASM-JMP takes captured unassembled code from DEBUG  (which
  86.      we  will  name  FILE.DB)  and  finds all addresses referenced by
  87.      the various Jump, Call, and Loop instructions.  These referenced
  88.      addresses  are  made  into  labels of the form Lhhhh (where hhhh
  89.      is the hex address).  A new  file  (FILE.JMP)  is  then  written
  90.      in  the  form  of  assembler  source code.  All of the addresses
  91.      and hex opcodes in the left two columns  of  the  DEBUG  listing
  92.      are  left  out.   Referenced  lines are appropriately labeled as
  93.      Lhhhh:.  
  94.  
  95.           UASM-INT reads FILE.JMP and writes  FILE.INT  in  which  it
  96.      has added Macro calls and comments explaining the various Inter-
  97.      rupts.  The macros, symbols, and  comments  are  read  from  the
  98.      file  UASM-DOS.MAC.  This file contains a table of EQUates which
  99.      define the symbols for the various DOS function  calls  and  the
  100.      DOSCALL  macro.   It  is  included  in  FILE.INT  by means of an
  101.      INCLUDE directive.
  102.  
  103.           UASM-STR reads FILE.INT  and  writes  FILE.STR,  attempting
  104.      to  find  all  strings  and variables used by FILE.COM.  When it
  105.      finds an address it reads the string or variable  from  FILE.COM
  106.      and generates the appropriate data statement (e.g. Dhhhh    DB
  107.           'string')  which  it appends to FILE.STR, and comments each
  108.      line of code which references that address.
  109.  
  110.           From that point on, you  must  take  over  and  supply  the
  111.      remaining  text  strings  and variables that are addressed.  You
  112.      should heavily comment the code as you go through it and  change
  113.      the  labels  that  UASM has assigned into more meaningful names.
  114.      This is best done with the global change command  in  your  text
  115.      editor.  I also recommend using the Macro CREF program to obtain
  116.      a cross reference map of the symbols.
  117.  
  118.           These programs are by no means  infallible,  and  they  can
  119.      no  more  read  the programmers' mind than you or I, so you will
  120.      have to check the output  closely.   If  you  expect  to  simply
  121.      run  UASM  and  be  handed  a usable source file you're going to
  122.      be disappointed.  On the other hand, if  you've  ever  tried  to
  123.  
  124.  
  125.  
  126.  
  127.  
  128.  
  129.  
  130.  
  131.  
  132.  
  133.  
  134.  
  135.                                                                           3
  136.  
  137.      understand  a  program  from  just  a  DEBUG listing you will be
  138.      pleasantly surprised.  UASM  will  aid  you  in  studying  other
  139.      programs  by  doing  a lot of the dirty work for you, but if you
  140.      don't study the code you won't get usable output.
  141.        
  142.           I have been using these programs  to  unassemble  DEBUG.COM
  143.      and  COMMAND.COM.   When  I  have  them sufficiently commented I
  144.      will post them on the BBS's.  It  is  my  hope  that  UASM  will
  145.      lead  to a whole library of well commented, "reverse engineered"
  146.      source code for  the  MS-DOS  operating  system  and  utilities.
  147.      I  would  appreciate  anyone  else working on the same to upload
  148.      your results to the BBS.  Suggestions and improvements  to  UASM
  149.      are  welcome.   I  may  be  contacted  through any of the IBM-PC
  150.      BBS's in Atlanta, or write: 
  151.  
  152.                      Guy C. Gordon
  153.                White Crane Systems
  154.                3194 Friar Tuck Way
  155.                Doraville, GA 30340
  156.  
  157.  
  158.  
  159.  
  160.  
  161.  
  162.  
  163.  
  164.  
  165.  
  166.  
  167.  
  168.  
  169.  
  170.  
  171.  
  172.  
  173.  
  174.  
  175.  
  176.  
  177.  
  178.  
  179.  
  180.  
  181.  
  182.  
  183.  
  184.  
  185.  
  186.  
  187.  
  188.  
  189.  
  190.  
  191.  
  192.  
  193.  
  194.  
  195.  
  196.  
  197.  
  198.  
  199.  
  200.  
  201.                                                                           4
  202.  
  203.                          OPERATING INSTRUCTIONS
  204.                                  -DEBUG-
  205.  
  206.           As an  example,  we  will  unassemble  a  fictitious  file,
  207.      FILE.COM
  208.      A>debug file.com
  209.      -r
  210.      .....CX=1780 ...         ;file length in hex bytes
  211.      -d 100 l 1780            ;display entire file
  212.  
  213.           In  the  listing  that  follows  you should be able to spot
  214.      ASCII text and any regular binary tables.  Write  down  the  be-
  215.      ginning  and  ending  addresses  of  these, as we do not want to
  216.      unassemble them, but we will  want  a  printed  copy.   Our  aim
  217.      is  to  put together a list of all blocks of code to be unassem-
  218.      bled and string addresses for UASM-STR.  Look at the code before
  219.      each  block  of  text.   Usually it will be preceded by a hex C3
  220.      which is a RET instruction, but there may be a JMP, JMPS,  IRET,
  221.      or  RETF instead.  This is the last instruction we want to unas-
  222.      semble in the block of  code  preceding  the  text.   Take  your
  223.      time  and  go  through  the  entire  file, unassembling code and
  224.      making sure that the output looks reasonable.  
  225.  
  226.           Reasonable code contains such things as CALL  or  Jump  in-
  227.      structions to nearby addresses, INT 21 instructions and multiple
  228.      operations on single registers.  It does not contain DB instruc-
  229.      tions  or  very many 00 bytes.  Also the ASCII display of a sec-
  230.      tion of code will look totally random,  with  about  50%  of  it
  231.      being  displayable  characters.   (The  rest  will  be periods.)
  232.       Peter Norton has given a good demonstration of this in  chapter
  233.      6  of  "Inside  the IBM-PC".  One warning--the DEBUG unassembler
  234.      tends to lock into phase with the correct code,  which  is  very
  235.      nice,  but  be  certain  that the beginning few instructions are
  236.      also in phase.  Sections of code that are in phase will  contain
  237.      Jumps  and  CALLs  to  other sections, thus telling you where to
  238.      start unassembling.
  239.  
  240.           At the end of this  investigation  of  the  .COM  file  you
  241.      should  have  a  list  of  the  starting and ending addresses of
  242.      all the code blocks and all the string blocks.   The  next  step
  243.      depends upon whether you have DOS 2.0 or not.  It is much easier
  244.      if you have 2.0, or can to  this  part  on  a  friend's  machine
  245.      who  has  it.   This  is  because  under DOS 2.0 we can pipe the
  246.      output of DEBUG into  a  file  thus  capturing  the  unassembled
  247.      code for input to UASM-JMP.  Under DOS version 1. we must modify
  248.      DEBUG (using DEBUG of course) to get it to  write  the  file  we
  249.      need.
  250.  
  251.  
  252.  
  253.  
  254.  
  255.  
  256.  
  257.  
  258.  
  259.  
  260.  
  261.  
  262.  
  263.  
  264.  
  265.  
  266.  
  267.                                                                           5
  268.  
  269.                         DEBUG - 2.0 Instructions
  270.  
  271.           Create  a  file, FILE.IN, with the following DEBUG instruc-
  272.      tions:
  273.  
  274.      u addr 1 addr 2               ;addresses of blocks of
  275.      u addr 3 addr 4               ; code to unassemble
  276.      u addr 5 addr 6               ; from our initial investigation
  277.      q                        ;Must have Quit instruction at end
  278.  
  279.           Now we can run DEBUG and pipe the output to a disk file.
  280.  
  281.      DEBUG FILE.COM <FILE.IN >FILE.DB
  282.  
  283.           FILE.DB is the input for UASM-JMP.
  284.  
  285.  
  286.  
  287.  
  288.                         DEBUG - 1.1 Instructions
  289.  
  290.          While it is quite easy to capture the output of DEBUG  under
  291.      DOS  2.0  since we can pipe it to a file, under earlier versions
  292.      of DOS we have no such option.  However, DEBUG is an exceptional-
  293.      ly powerful program, and already  contains  the  code  necessary
  294.      to  write  a disk file with the Write command.  We will use this
  295.      to capture the Unassembled code.  
  296.  
  297.           If we unassemble and examine DEBUG, we can find the follow-
  298.      ing subroutine:
  299.  
  300.      02C8:02C0 PUSH AX        ;save registers
  301.                PUSH DX
  302.                AND  AL,7F          ;insure character is ASCII
  303.                XCHG DX,AX          ;put character in DL
  304.                MOV  AH,02          ;DOS Function 2 to display DL
  305.                INT  21
  306.                POP  DX        ;restore registers
  307.                POP  AX
  308.                RET            ;return
  309.  
  310.           As  it  turns  out,  DEBUG  does  all screen output through
  311.      this subroutine.  Thus we can modify just  this  subroutine  and
  312.      capture  each  character  as  it  is displayed.  What we will do
  313.      with it is write it out to an unused portion  of  memory.   From
  314.      there  we  can  write  all  the output to a file using the Write
  315.      command.
  316.  
  317.  
  318.  
  319.  
  320.  
  321.  
  322.  
  323.  
  324.  
  325.  
  326.  
  327.  
  328.  
  329.  
  330.  
  331.  
  332.  
  333.                                                                           6
  334.  
  335.           Our subroutine to store character AL in consecutive  memory
  336.      locations  will be very small--about 20 bytes.  We'll need some-
  337.      place to put it.  For DEBUG 1.07 I chose  to  put  it  inside  a
  338.      string  which  is  only printed once--the message "DEBUG version
  339.      1.07" located at CS:0102.  Here is the subroutine:
  340.  
  341.      02C8:0102 DW   3300      ;pointer to memory
  342.                PUSH DI        ;save index register
  343.                SEG  CS        ;offset from code, not ES
  344.                MOV  DI,[0102] ;get pointer
  345.                SEG  CS        ;
  346.                STOSB          ;store char in AL into memory
  347.                SEG  CS        ;
  348.                MOV  [0102],DI ;store incremented pointer
  349.                POP  DI        ;restore register
  350.                XCHG DX,AX     ;complete the instructions that
  351.                MOV  AH,02     ; CALL to this routine replaced
  352.                RET            ;Return to Display routine
  353.  
  354.           We can store this  subroutine  over  the  string  with  the
  355.      Enter  command.  (here  02C8  is the base segment where DEBUG is
  356.      loaded on my system):
  357.  
  358.      E 2C8:102 00 33 57 2E 8B 3E 02 01 2E AA 2E 89 3E  02  01  5F  92
  359.                B4 02 C3
  360.  
  361.      We  can  check  that  this was entered correctly by Unassembling
  362.      it:
  363.  
  364.      U 2C8:104      ;you should see the subroutine listed above.
  365.  
  366.           The choice of memory location is up to you.   3300  Is  the
  367.      value  I  used  while  unassembling  DEBUG.  It should be larger
  368.      than the sum of the sizes (in bytes) of DEBUG  and  the  program
  369.      you  are  unassembling.   To  have  this  subroutine called each
  370.      time DEBUG writes a character, we insert a subroutine Call:
  371.  
  372.      E 2C8:2C4 E8 3D FE       ;Call 0104
  373.  
  374.      This puts a CALL 0104 in place of  XCHG  DX,AX  and  MOV  AH,02.
  375.      That  is  why  we  perform  those  instructions before returning
  376.      to the display routine.  The very next charter printed by  DEBUG
  377.      after  you  Enter  the  above command will be stored in location
  378.      2C8:3300 as well as displayed on the screen. 
  379.  
  380.  
  381.  
  382.  
  383.  
  384.  
  385.  
  386.  
  387.  
  388.  
  389.  
  390.  
  391.  
  392.  
  393.  
  394.  
  395.  
  396.  
  397.  
  398.  
  399.                                                                           7
  400.  
  401.           Immediately  after  entering  the  CALL  instruction  above
  402.      you  should  begin  the  Unassemble commands that you determined
  403.      will give you all the code for the program.  
  404.  
  405.      U 100 4D5
  406.      U 6b0 799
  407.      etc.
  408.      D 2C8:102 103  ;This displays the pointer to the end of text
  409.           B3 D9          ;This means we filled memory to D9B3
  410.                          ;(remember the 8088 stores words LSB first)
  411.      H D9B3 3300         ;Hex arithmetic
  412.           0CB3 A6B3      ;  D9B3 - 3300 = A6B3
  413.      R CX
  414.           CX=1748
  415.           :A6B3          ;load CX register with # of bytes to write
  416.      N FILE.DB           ;name the output file
  417.      W 2C8:3300          ;writing from 3300 off. from DEBUG base
  418.         Writing A6B3 bytes
  419.      E 2C8:102 00 33          ;reset pointer if out of space
  420.  
  421.           Remember, you can only write text to  memory  up  to  2C8:-
  422.      FFFF.   If you exceed that you will write over DEBUG at 2C8:0000
  423.      and will probably have to  re-boot.   If  FILE.COM  is  too  big
  424.      to  Unassemble  in  one  pass you'll have to do it in pieces and
  425.      append them together with your text  editor.   For  this  reason
  426.      it  is  a  good  idea  to  modify and save a copy of DEBUG under
  427.      another name such as UDEBUG.  If you need to perform  any  other
  428.      operations  with  a  modified DEBUG that you do not want written
  429.      to memory you can restore DEBUG to normal operation with:
  430.  
  431.      E 2C8:2C4 92 B4 02  ;restores XCHG DX,AX and MOV AH,02
  432.  
  433.          Now text edit FILE.DB and remove any extraneous  lines  such
  434.      as  debug  prompts  that  might  have  been displayed.  If there
  435.      are any TABs in FILE.DB  they  will  confuse  UASM-JMP  and  the
  436.      others.   DEBUG  1.1 appears to put a TAB after each instruction
  437.      while version 2.0 does not.  I always use  the  text  editor  to
  438.      change  all  TABs  to  the appropriate number of spaces.  (Users
  439.      of PMATE, use the YF command.)
  440.  
  441.           Any of the memory addresses above may vary with your operat-
  442.      ing system and DEBUG version.  The  values  given  are  for  the
  443.      Victor  9000,  MS-DOS  1.25a,  and DEBUG 1.07.  The Base Segment
  444.      where DEBUG is loaded (2C8 above) will depend upon your  machine
  445.      and  operating  system,  and  is  found by using DEBUG to Search
  446.      for itself in memory.  The display subroutine  (2C0  above)  de-
  447.      pends  upon  your  DEBUG  version  number.   The same subroutine
  448.      occurs at 2B5 in the DEBUG that  comes  with  PC-DOS  1.10,  and
  449.      will  appear near these locations in any other version 1 DEBUGs.
  450.      If you store the capture  subroutine  at  some  other  place  in
  451.      memory  you  need  to  change  the two [0102] references and the
  452.      CALL 0104 instruction.  
  453.  
  454.  
  455.  
  456.  
  457.  
  458.  
  459.  
  460.  
  461.  
  462.  
  463.  
  464.  
  465.                                                                           8
  466.  
  467.                          UASM-JMP  Instructions
  468.  
  469.            Run UASM-JMP as you would  any  basic  program.   It  will
  470.      prompt  you  for  the  name of input and output files.   Respond
  471.      with  FILE.DB ,which we created above, and B:FILE.JMP  for  out-
  472.      put.   If  file  extensions  are not provided, .DB and .JMP will
  473.      be assumed for input and output respectively.  Also  the  output
  474.      file  name  will default to the input file name. I highly recom-
  475.      mend putting these files on separate drives if  you  don't  have
  476.      a  fixed  disk  or  a  RAM disk.  This will speed up the program
  477.      and save wear on your floppies.
  478.  
  479.           UASM-JMP will make  two  passes  through  the  input  file.
  480.      On  the first pass it will build a list of all referenced lines.
  481.      It then sorts  this  list  (shell  sort),  eliminates  duplicate
  482.      references,  and on the second pass, labels all of the referenc-
  483.      es.  The output will be displayed on  your  screen  as  well  as
  484.      written out on the second pass.  
  485.  
  486.           If  the  program  finds  a  Jump  or CALL to an address not
  487.      contained in the file you will  get  the  message  "WARNING!  No
  488.      code  for  this  label".   This most likely means you missed the
  489.      block of code starting at address hhhh  and  will  have  to  add
  490.      it  to  FILE.DB.   The  statement after an unconditional program
  491.      transfer (JMP or RET) is always labeled.  The message  "WARNING!
  492.      This  label  not referenced" means that there is no Jump or CALL
  493.      to this label.  It might be an interrupt handler or, in a highly
  494.      modified  program,  it  might  be code left over from an earlier
  495.      version which is no  longer  executed.   (NOP  instructions  are
  496.      not  force  labeled, but the following instruction is.)  A large
  497.      number of these errors might indicate  that  they  are  accessed
  498.      by  an  address  table.   Both  of  the above errors might occur
  499.      if you miss a block of code, unassemble  a  data  area,  or  the
  500.      code modifies itself.
  501.  
  502.           For  added  readability,  UASM-JMP  inserts  one blank line
  503.      after each JMP or JMPS  instruction  and  three  lines  after  a
  504.      RET or IRET.  This helps separate Proceedures.
  505.  
  506.  
  507.  
  508.                          UASM-INT  Instructions
  509.  
  510.           To  run  UASM-INT  you  must  also have the data file UASM-
  511.      DOS.MAC on one of the drives.   UASM-INT  will  prompt  you  for
  512.      an input and output file names.  If extensions are not provided,
  513.      .JMP and .INT will be assumed for input and  output  respective-
  514.      ly.   The program then loads the symbol table contained in UASM-
  515.      DOS.MAC.   While reading  through  FILE.JMP,  whenever  UASM-INT
  516.      encounters  an  INT  instruction  it  adds a Macro call, Symbols
  517.      for the DOS function calls, and Comments,  all  from  the  UASM-
  518.      DOS.MAC  file.  These lines will also be displayed on the screen
  519.      as the program progresses.   Note  that  the  DOSCALL  Macro  is
  520.      inserted  in the text, but the INT instructions are not deleted.
  521.      After you have checked the code you  must  delete  the  INT  and
  522.      any MOV instructions that will be duplicated by the Macro.
  523.  
  524.  
  525.  
  526.  
  527.  
  528.  
  529.  
  530.  
  531.                                                                           9
  532.  
  533.                           UASM-STR Instructions
  534.  
  535.           To  run  UASM-STR  you  must  have the original FILE.COM or
  536.      other binary file on disk.  The  program  will  prompt  you  for
  537.      the  input,  output,  and binary file names.  These will default
  538.      to .INT, .STR and .COM if  no  other  extension  is  given.   As
  539.      usual,  the  input  file  name  will be used as a default if you
  540.      do not specify the others, and you should put  the  output  file
  541.      on a different floppy drive than the input file.  
  542.  
  543.           You  will  then  be  prompted for any string area addresses
  544.      that you may have found while  examining  FILE.COM  with  DEBUG.
  545.      You  may  enter  an  address  range  (hhhh kkkk), the address of
  546.      a single string (hhhh), or an address and  a  length  (hhhh  Ln)
  547.      on  each  line.  (Up  to 20 lines).  Upon receiving a blank line
  548.      as input, the program will  find  all  strings  terminated  with
  549.      a  $ starting at the first address in a range and continue find-
  550.      ing multiple strings to  the  second  address  if  present.   If
  551.      a  single  address  is  given  on a line a single string will be
  552.      read.  If a length is provided, the  string  will  be  truncated
  553.      to  that  length  or  at the terminator, which ever comes first.
  554.      (This is useful for data string which do not  have  $  terminat-
  555.      ors.)  Each string is displayed as it is found.  
  556.  
  557.           Following  this  the  program  reads through FILE.INT.  For
  558.      each "DOSCALL PRINT$  hhhh"  encountered  it  reads  the  string
  559.      from  FILE.COM  at  the  specified location (taking into account
  560.      the 100H byte program prefix) and prints that string as  a  com-
  561.      ment  next  to  the Macro.  Also, each time a register is loaded
  562.      with the address of a string,  that  string  is  shown  next  to
  563.      the code.  At the end of the file, UASM-INT will append a number
  564.      of EQUates and Data statements and define the  string  variables
  565.      with  names  Dhhhh.   Non-printing characters are converted into
  566.      hex bytes.  CR, LF, TAB, ESC, and $ are defined as symbols.
  567.  
  568.           DOSCALLs that do file I/O and  that  load  the  address  of
  569.      the  File  Control  Block  into  DX  will generate that FCB as a
  570.      string.   Any  address  which  is  used  within  brackets  (e.g.
  571.      LEA   DX,[hhhh]),  that  is  not already a known string address,
  572.      is assumed to be the address of a variable.   A  data  statement
  573.      is  generated  for  the  variable,  and  two bytes are extracted
  574.      from FILE.COM to show its initial value.
  575.  
  576.  
  577.  
  578.  
  579.  
  580.  
  581.  
  582.  
  583.  
  584.  
  585.  
  586.  
  587.  
  588.  
  589.  
  590.  
  591.  
  592.  
  593.  
  594.  
  595.  
  596.  
  597.                                                                          10
  598.  
  599.                  SAMPLE OUTPUT - Excerpts from DEBUG.STR
  600.  
  601. INCLUDE   UASM-DOS.MAC
  602. .RADIX    16 
  603.  
  604. START:  JMPS    L011D            
  605.  
  606. L011D:  MOV     SP,1822 
  607.         MOV     [1897],AL 
  608.         MOV     DX,0102 
  609.         MOV     AH,09 
  610.         INT     21 
  611.  
  612. DOSCALL PRINT$,D0102       ;CR,LF,'DEBUG-86  version 1.07',CR,LF,$ 
  613.         MOV     AX,2522 
  614.         MOV     DX,01E6 
  615.         INT     21 
  616.  
  617. DOSCALL SET$INT     01E6   ; Set interrupt vector (AL=INT, DS:DX=VECTOR)
  618.  
  619.         MOV     AL,23 
  620.         MOV     DX,01EB 
  621.         INT     21 
  622.  
  623. DOSCALL SET$INT     01EB   ; Set interrupt vector (AL=INT, DS:DX=VECTOR)
  624.  
  625.         MOV     DX,CS 
  626.         ADD     DX,01AB 
  627.         MOV     AH,26 
  628.         INT     21 
  629.  
  630. DOSCALL BUILD$PS    01AB      ; Create new program  segment  (DX=SEGMENT)
  631.  
  632.  
  633.         MOV     AX,DX 
  634.         MOV     DI,1832 
  635.         STOSW 
  636.         MOV     DX,0080 
  637.         MOV     AH,1A 
  638.         INT     21 
  639.  
  640. DOSCALL SET$DTA     0080      ; Set Disk Transfer Address to DX 
  641.  
  642.         MOV     AX,[0006] 
  643.         MOV     BX,AX 
  644.         CMP     AX,FFF0 
  645.         PUSH    CS 
  646.         POP     DS 
  647.         ADD     [0008],BX 
  648.         MOV     DI,005C 
  649.         MOV     SI,0081 
  650.         MOV     AX,2901 
  651.  
  652.  
  653.  
  654.  
  655.  
  656.  
  657.  
  658.  
  659.  
  660.  
  661.  
  662.  
  663.                                                                          11
  664.  
  665.         INT     21 
  666.  
  667. DOSCALL PARSE$         ; Parse Filespec (SI -> LINE, DI -> FCB, AL=CODE)
  668.  
  669.         CALL    L0917 
  670.         PUSH    CS 
  671.         POP     ES 
  672.         CMP     B,[005D],20 
  673.         JZ      L01B5 
  674.         JMPS    L01B5 
  675.  
  676. L01E3:  JMP     L04CB 
  677.  
  678. L01E6:   MOV      DX,167A             ;WARNING! This label not referenced
  679.         MOV     DS,AX 
  680.         MOV     SS,AX 
  681.         MOV     SP,1822 
  682.         MOV     AH,09 
  683.         INT     21 
  684.  
  685. DOSCALL PRINT$            ; Display string @DX till terminator 
  686.  
  687.         JMPS    L01B5 
  688.  
  689. L01FD:  MOV     AH,0A 
  690.         MOV     DX,1844 
  691.         INT     21 
  692.  
  693. DOSCALL INSTR$      1844  ; Input keyboard string (DX -> size,cnt,buffer)
  694.  
  695.         MOV     SI,1846 
  696. ;END CODE 
  697. .RADIX    16 
  698. CR   EQU  0D 
  699. LF   EQU  0A 
  700. TAB  EQU  09 
  701. ESC  EQU  1B 
  702. $    EQU  24 
  703. D167A     DB   CR,LF,'Program terminated normally',CR,LF,$ 
  704. D169A     DB   'Invalid drive or file name',CR,LF,$ 
  705. D16B7     DB   'File not found',CR,LF,$ 
  706. D16C8     DB   'No room in disk directory',CR,LF,$ 
  707. D16E4     DB   'Insufficient space on disk',CR,LF,$ 
  708. D1701     DB   'Disk$' 
  709. D1706     DB   'Write protect$' 
  710. D1714     DB   ' error reading drive A',CR,LF,$ 
  711. D172D     DB   'readwritInsufficient memory',CR,LF,$ 
  712. D174B     DB   '^ Error',CR,8A,' ',88,'Error in EXE/HEX file',CR,LF,$
  713. D176E     DB   'EXE/HEX file cannot be written',CR,LF,$ 
  714. D178F     DB   'Writing $' 
  715. D1798     DB   ' bytes',CR,LF,$ 
  716. D0102     DB   CR,LF,'DEBUG-86  version 1.07',CR,LF,$ 
  717.  
  718.  
  719.  
  720.  
  721.  
  722.  
  723.  
  724.  
  725.  
  726.  
  727.  
  728.  
  729. D1798     DB   ' bytes',CR,LF,$ 
  730. D0102     DB   CR,LF,'DEBUG-86  version 1.07',CR,LF,$ 
  731.  
  732.  
  733.  
  734.  
  735.  
  736.  
  737.  
  738.  
  739.  
  740.  
  741.  
  742.  
  743. D1798     DB   ' bytes',CR,LF,$ 
  744. D0102     DB   CR,LF,'DEBUG-86  version 1.07',CR,LF,$ 
  745.  
  746.  
  747.  
  748.  
  749.  
  750.  
  751.  
  752.  
  753.  
  754.  
  755.  
  756.